/*
 ============================================================================
 Name        : RAID1.c
 Author      : 
 Version     :
 Copyright   : Your copyright notice
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include "headers/GlobalHeader.h"
#include <pthread.h>

int32_t flag = 0,flag_escritura = 0;
int32_t planificadoresConectados = 0, planificador_listo, planificador_termino, cantidadSectores=0;
int32_t raid_en_funcionamiento = 0, sincronizacion_en_curso = 0;
pthread_mutex_t mutexColaGrande;
pthread_mutex_t mutexColaPedidosEnProceso;
pthread_mutex_t mutexInfoConsola;
pthread_mutex_t mutexlisto;
sem_t *sem_consola;
sem_t *sem_inicio_escritura;
sem_t *sem_fin_escritura;
int32_t correr_consola = 1, cantidadClientesPFS=0;
consola *paquete_consola;
t_nodoCola  *frente_colaPedidosEnProceso=NULL, *fin_colaPedidosEnProceso= NULL;
nipc paquete_escritura;
config configuracion;
t_log *logger;
NodoPFS *listaPFS = NULL;


void thread_recibo_info (void *parametro);
void thread_cliente_pfs (void *parametro);
void thread_cliente_ppd (void *parametro);
void thread_planificador(void *);
void thread_consola (void *parametro);
void ver_cambios_consola();
void conexion_sincronizacion (t_nodoColaGrande **frente_colaGrande, t_nodoColaGrande **fin_colaGrande,char planificador_id[25],int32_t socket_id);
void desconexion_ppd(t_nodoColaGrande **,t_nodoColaGrande **, char[25]);

int main(void) {

	//char type;
	//t_nodoCola *fin_cpnd = NULL;

	//t_nodoCola *frente_cpnd = NULL;
	t_nodoColaGrande *frente_colaGrande = NULL;
	t_nodoColaGrande *fin_colaGrande = NULL;
	//t_pedido pedido;
	pthread_t thread_consola_id, thread_cliente_pfs_id, threads_plan;
	pthread_mutexattr_t mutexattr;
	estructuraThread estruct_thread;

	char carac;
	int32_t current_size,rv,a,yes = 1, respuesta;
	int32_t addrlen = sizeof(struct sockaddr_in);
	int32_t socket_server_pfs = socket(AF_INET,SOCK_STREAM,0);
	int32_t socket_server_ppd = socket(AF_INET,SOCK_STREAM,0);
	int32_t cliente_pfs;
	int32_t cliente_ppd;
	int32_t descriptor_maximo;

	//int32_t clientes_ppd[CANT_CLIENTES_PPD_MAX];
	//int32_t cliente_pdd;
	fd_set sockets_que_espero;
	nipc paquete_recibo,paquete_mando;

	NodoPFS *auxPFS=NULL;

	// Cargo Struct de Configuracion
	cargaConfiguracionInicial();
	correr_consola = configuracion.ConsolaActiva;
	//int32_t CANT_CLIENTES_PFS_MAXI = configuracion.cantPFSMax;

	int32_t clientes_pfs[CANT_CLIENTES_PFS_MAXI];

	if(configuracion.logActivado==1){
		logger = log_create("Runner", "RAID.log", DEBUG | INFO | WARNING, M_CONSOLE_DISABLE);
	}

	inicializoArray(clientes_pfs);

	//correr_consola=getInt("ConsolaActiva");

	struct pollfd ufds[CANT_CLIENTES_PFS_MAXI+2];

	//CONFIGURACION SOCKETS

//	if (setsockopt(socket_server_pfs, SOL_SOCKET, SO_REUSEADDR,&yes, sizeof(int)) == -1) {
//		perror("setsockopt");
//		exit(1);
//	}
//	if (setsockopt(socket_server_ppd, SOL_SOCKET, SO_REUSEADDR,&yes, sizeof(int)) == -1) {
//		perror("setsockopt");
//		exit(1);
//	}

	//Direccion local pfs
	struct sockaddr_in *direccion_local_pfs = malloc(addrlen);
	//Direccion remota(a la que me quiero conectar)
	struct sockaddr_in *direccion_remota_pfs = malloc(addrlen);

	direccion_local_pfs->sin_family = AF_INET;
	direccion_local_pfs->sin_addr.s_addr = inet_addr(configuracion.IPRAID);
	//direccion_local_pfs->sin_port = htons(configuracion.PuertoEscuchaPfs);
	direccion_local_pfs->sin_port = htons(configuracion.PuertoEscuchaPfs);
	bind(socket_server_pfs,(struct sockaddr *)direccion_local_pfs, addrlen);

	//Direccion local ppd
	struct sockaddr_in *direccion_local_ppd = malloc(addrlen);
	//Direccion remota(a la que me quiero conectar)
	struct sockaddr_in *direccion_remota_ppd = malloc(addrlen);

	direccion_local_ppd->sin_family = AF_INET;
	direccion_local_ppd->sin_addr.s_addr = inet_addr(configuracion.IPRAID);
	//direccion_local_ppd->sin_port = htons(configuracion.PuertoEscuchaPpd);
	direccion_local_ppd->sin_port = htons(configuracion.PuertoEscuchaPpd);
	bind(socket_server_ppd,(struct sockaddr *)direccion_local_ppd, addrlen);

	//INICIO MUTEXES
	//pthread_mutexattr_init(&mutexattr);
	//pthread_mutexattr_setpshared (&mutexattr,PTHREAD_PROCESS_SHARED);
	//pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);
	pthread_mutex_init (&mutexColaGrande, NULL);
	pthread_mutex_init (&mutexInfoConsola, NULL);
	pthread_mutex_init (&mutexColaPedidosEnProceso,NULL);
	//pthread_mutex_init (&mutexlisto, NULL);

	//INICIO SEMAFOROS
	sem_inicio_escritura = sem_open ("/sem_1", O_CREAT, 0644, 0);
	if(sem_inicio_escritura == (sem_t *)-1)
	perror("Error creando semáforo inicio_escritura");

	sem_fin_escritura = sem_open ("/sem_2", O_CREAT, 0644, 0);
	if(sem_fin_escritura == (sem_t *)-1)
	perror("Error creando semáforo fin_escritura");

	sem_consola = sem_open ("/sem_consola", O_CREAT, 0644, 0);
	if(sem_consola == (sem_t *)-1)
	perror("Error creando semáforo inicio_escritura");

	//pthread_create (&thread_cliente_ppd_id, NULL,(void*) &thread_cliente_ppd,(void *) &a);
	//pthread_create (&thread_cliente_pfs_id, NULL,(void*) &thread_cliente_pfs,(void *) &a);


	//SI LA CONSOLA ESTA ACTIVADA CREO THREAD CONSOLA, INICIALIZO INFO CONSOLA Y ASIGNO RUTINA A SEÑAL
	if(correr_consola == 1){
		paquete_consola = (consola*) malloc (sizeof(consola));
		paquete_consola->infoConsola = (t_infoConsola *) malloc(sizeof (t_infoConsola));

		signal(SIGUSR1,ver_cambios_consola);
		pthread_create (&thread_consola_id, NULL,(void*) &thread_consola,(void *) &paquete_consola);
		pthread_mutex_lock (&mutexInfoConsola);
		//INICIALIZO INFO CONSOLA EN 0 (SIN CAMBIOS)
		paquete_consola->thread_consola_id = thread_consola_id;
		paquete_consola->infoConsola->inicioRaid = 0;
		paquete_consola->infoConsola->nuevoPlanificador = 0;
		strcpy(paquete_consola->infoConsola->planificadorNuevo_id,"");
		paquete_consola->infoConsola->iSincronizacion = 0;
		paquete_consola->infoConsola->fSincronizacion = 0;
		paquete_consola->infoConsola->escritura = 0;
		paquete_consola->infoConsola->lectura = 0;
		strcpy(paquete_consola->infoConsola->planificador_id,"");
		pthread_mutex_unlock (&mutexInfoConsola);
	}

	puts("!!!Hola soy el RAID!!!"); /* prints !!!Hello World!!! */

	if((listen(socket_server_pfs,CANT_CLIENTES_PFS_MAXI)) == -1) {
		perror("listen");
	}

  if((listen(socket_server_ppd,CANT_CLIENTES_PPD_MAX)) == -1) {
	  perror("listen");
   }

  FD_ZERO (&sockets_que_espero);
  FD_SET(socket_server_pfs,&sockets_que_espero);
  descriptor_maximo = socket_server_pfs;
  FD_SET(socket_server_ppd,&sockets_que_espero);
  if(socket_server_ppd > descriptor_maximo) descriptor_maximo = socket_server_ppd;

  memset(ufds, 0 , sizeof(ufds));
  int nfds = 2;

  ufds[0].fd = socket_server_pfs;
  ufds[0].events = POLLIN;

  ufds[1].fd = socket_server_ppd;
  ufds[1].events = POLLIN;

  while(1){
	  current_size = nfds;
	  rv = poll(ufds, nfds, -1);
	 // printf("alguien me mando algo %i\n",rv);
	  if(ufds[0].revents & POLLIN) {
		  cliente_pfs = accept(socket_server_pfs,(struct sockaddr *)direccion_remota_pfs,(void *)&addrlen);

		  printf("acepte pfs, descriptor :%i\n",cliente_pfs);
		  //insertarEnArray(clientes_pfs,cliente_pfs);
		  insertarEnListaClientes(cliente_pfs);

		  ufds[nfds].fd = cliente_pfs;
		  ufds[nfds].events = POLLIN;
		  nfds++;
	  }
	  if(ufds[1].revents & POLLIN) {
		  cliente_ppd = accept(socket_server_ppd,(struct sockaddr *)direccion_remota_ppd,(void *)&addrlen);

		  //printf("acepte ppd, descriptor :%i\n",cliente_ppd);
		  estruct_thread.frenteColaGrande = &frente_colaGrande;
		  estruct_thread.socket_id = cliente_ppd;
		  estruct_thread.finColaGrande = &fin_colaGrande; //ANDA BIEN
		  pthread_mutex_lock (&mutexColaGrande);
		  pthread_create (&threads_plan, NULL,(void*) &thread_planificador,(void *) &estruct_thread);
		  pthread_mutex_unlock (&mutexColaGrande);
		  sleep(1);
	  }
	  a=0;
	  //for(a=0; a<CANT_CLIENTES_PFS_MAXI; a++){

	  auxPFS=listaPFS;
	  while(auxPFS != NULL){
	  	  if(ufds[a+2].revents & POLLIN){
			//if(ufds[auxPFS->cliente_pfs+2].revents & POLLIN){
		  	  if((respuesta = recv(auxPFS->cliente_pfs,&paquete_recibo,sizeof(nipc),MSG_WAITALL)) > 0){

				  if(paquete_recibo.type == 0){ //ES HANDSHAKE
					  if(raid_en_funcionamiento){
						  paquete_mando.type = 0;
						  paquete_mando.payloadlength = sizeof(t_pedido);
						  paquete_mando.payload.conexion_pfs_id = auxPFS->cliente_pfs;
						  send(auxPFS->cliente_pfs,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);

						  //puts("MANDO UN TYPE 0");
					  }
					  else{
						  paquete_mando.type = 0;
						  paquete_mando.payloadlength = sizeof(t_pedido);
						  strcpy(paquete_mando.payload.info,"RAID NO ACTIVO");
						  send(auxPFS->cliente_pfs,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);
						  puts("RAID NO ACTIVO");
					  }
				  }
				  if(paquete_recibo.type == LECTURA){
					  distribucion_pedido(paquete_recibo.payload,&frente_colaGrande);
					  //MANDO PEDIDO A PPD
				  }
				  if(paquete_recibo.type == ESCRITURA){
					  if (configuracion.logActivado==1)
					  	   log_info(logger, "MAIN", "Llego un pedido de escritura y se procesará en todos los discos");
					  //MANDO PEDIDO A PROCESO ESCRITURA
					  paquete_recibo.payload.conexion_pfs_id = auxPFS->cliente_pfs;
					  pedido_escritura(paquete_recibo.payload,&frente_colaGrande);
				  }
			  }
			  else{
				  if(respuesta == -1){
					  perror("recv");
					  close(auxPFS->cliente_pfs);
				  }
				  else{
				  //EL CLIENTE CERRO LA CONEXION
				  //ELIMINO CLIENTE DEL ARRAY
				  puts("CERRO LA CONEXION");
				  while((carac = getchar()) != 'a'){
				  }
				  borrarDeListaClientes(auxPFS->cliente_pfs);
				  //eliminoDeArray(clientes_ppd,clientes_pfs[a]);
				  close(auxPFS->cliente_pfs);
				  }
			  }

		  }
		  auxPFS= auxPFS->sig;
		  a++;
  	  //}
	  }
  }
  return EXIT_SUCCESS;
}
void thread_consola (void *parametro){
	//consola info_consola = *(consola *) parametro;

	//printf("comenzo el thread consola");

	sem_wait(sem_consola);
}

void thread_planificador (void *parametro){
	  int32_t hand_ok, i,k,j, valor, valor2;
	  estructuraThread estruct_thread = *(estructuraThread *) parametro, estruct_thread_recibo;
	  int32_t socket_ppd = estruct_thread.socket_id;
	  t_nodoColaGrande *frente_cola_planificador;//, **puntero1 = estruct_thread.frenteColaGrande;
	  //t_nodoColaGrande *finGrande = *estruct_thread.finColaGrande;
	  t_pedido pedido_a_mandar, pedido_para_trabajar, pedido_e;
	  pthread_t thread_id = 1, thread_recibo_info_id;
	  bool encontrado_y_removido;
	  nipc paquete_recibo, paquete_mando;
	  char ppd_a_sincronizar[25];

	  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
	  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

	  fd_set sockets_que_espero, sockets_select ;
	  int32_t descriptor_maximo;

	 // puts("inicio thread ppd");
	  while(hand_ok != 1){
		  if((recv(socket_ppd,&paquete_recibo,sizeof(nipc),MSG_WAITALL)) <= 0){
			perror("recv");
			//pthread_exit()
		  }
		  if(paquete_recibo.type == 0){ //ES HANDSHAKE
				hand_ok = 1;
				strcpy(estruct_thread.planificador_id,paquete_recibo.payload.planificador_id);
				//printf("nombre ppd: %s \n",paquete_recibo.payload.planificador_id);
				cantidadSectores = paquete_recibo.payload.direccionSector;
				//cantidadSectores = cantidadSectores -1;
				paquete_mando.type = 0;
				paquete_mando.payloadlength = 0;
				strcpy(paquete_mando.payload.info,"hand ok");
				send(socket_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);
				//printf("HANDSHAKE ");
		  }
	  }

	  FD_ZERO (&sockets_que_espero);
	  FD_SET(socket_ppd,&sockets_que_espero);
	  descriptor_maximo = socket_ppd;

	  pthread_mutex_lock (&mutexColaGrande);
	  frente_cola_planificador = agregar_cola_a_cola(estruct_thread.frenteColaGrande,estruct_thread.finColaGrande,estruct_thread.planificador_id,estruct_thread.socket_id);
	  pthread_mutex_unlock (&mutexColaGrande);

	  if(planificadoresConectados == 0) frente_cola_planificador->estado = LISTO;
	  else frente_cola_planificador->estado = SINCRONIZANDO;

	  pthread_mutex_lock (&mutexColaGrande);
	  thread_id = pthread_self();
	  frente_cola_planificador->thread_id = thread_id;
	  pthread_mutex_unlock (&mutexColaGrande);

	  strcpy(estruct_thread_recibo.planificador_id, frente_cola_planificador->planificador_id);
	  estruct_thread_recibo.socket_id = socket_ppd;
	  estruct_thread_recibo.frenteColaGrande = estruct_thread.frenteColaGrande;
	  estruct_thread_recibo.finColaGrande = estruct_thread.finColaGrande;
	  pthread_create (&thread_recibo_info_id, NULL,(void*) &thread_recibo_info,(void *) &estruct_thread_recibo);

	  //cantidadSectores = 300000;
	  //printf("%i",cantidadSectores);


	  if(planificadoresConectados >= 1){//SINCRONIZO DISCO

		  sincronizacion_en_curso++;

		  if(correr_consola == 1){
			  pthread_mutex_lock (&mutexInfoConsola);
			  paquete_consola->infoConsola->iSincronizacion = 1;
			  time(&paquete_consola->infoConsola->inicioSincronizacion);
			  strcpy(paquete_consola->infoConsola->planificadorNuevo_id,frente_cola_planificador->planificador_id);
			  pthread_kill(paquete_consola->thread_consola_id,SIGUSR1);
			  pthread_mutex_unlock (&mutexInfoConsola);
		  }

		  for(i=0; i!= (cantidadSectores); i++){
			  j = 0;
			  for(k=0; k!= 10000; k++){
				  if(i<cantidadSectores){
					  pedido_a_mandar.lectura_o_escritura = 'L';
					  pedido_a_mandar.direccionSector = i;
					  pedido_a_mandar.conexion_pfs_id = -1;
					 // printf("agregue pedido %i",pedido_a_mandar.direccionSector);
					  strcpy(pedido_a_mandar.info, estruct_thread.planificador_id);
					  distribucion_pedido (pedido_a_mandar,estruct_thread.frenteColaGrande);
					  i++;
					  j++;
				  }
			  }
			  for(k=0; k!= j; k++){
				  valor = sem_wait(&(frente_cola_planificador->semaforo_cola));

				  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));

				  if(frente_cola_planificador->ppd_muerto == 1){
					  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					  return;
				  }

				  pedido_e = frente_cola_planificador->siguiente->pedido;
			      pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
				  paquete_mando.type = ESCRITURA;
				  paquete_mando.payloadlength = sizeof(t_pedido);
				  //frente_cola_planificador->siguiente->pedido.lectura_o_escritura = 'E'; YA ESTA PUESTO
				  paquete_mando.payload = pedido_e;

				  sockets_select = sockets_que_espero;
				  select(descriptor_maximo+1,NULL,&sockets_select,NULL,NULL);

				  // printf("mande el %i",paquete_mando.payload.direccionSector);
				  if((send(socket_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL)) == -1){
					  perror("send");
					  //return;
				  }

				  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
				  if(frente_cola_planificador->ppd_muerto == 1){
					  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					  return;
				  }
				  encontrado_y_removido = suprimir_pedido_especifico_de_cola(&frente_cola_planificador, pedido_e);
				  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));

				  //sem_wait(&(frente_cola_planificador->semaforo_escritura));
			  }

			  	  //if(frente_cola_planificador->ppd_muerto == 1){
				//  return;
			  //}

			  for(k=0; k!= j; k++){
				  //send(socket_ppd,&paquete_mando,sizeof(nipc),0);
				  //if(paquete_mando.payload.direccionSector == 19999) printf("MANDE TODO \n");
				  if(frente_cola_planificador->ppd_muerto == 1){
					  return;
				  }
				  sem_wait(&(frente_cola_planificador->semaforo_escritura));
			  }

			  i--;
		  }
		  sleep(1);
		  //puts("LISTOOOOO");
//		  //recv(socket_ppd,&paquete_recibo,sizeof(nipc),0);
//		  while(contador < cantidadSectores){
//			 // pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
//			  valor = sem_wait(&(frente_cola_planificador->semaforo_cola));
//			  //if(frente_cola_planificador->siguiente != NULL){
//				  pedido_e = frente_cola_planificador->siguiente->pedido;
//				//  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
//				  paquete_mando.type = ESCRITURA;
//				  paquete_mando.payloadlength = sizeof(t_pedido);
//				  //frente_cola_planificador->siguiente->pedido.lectura_o_escritura = 'E'; YA ESTA PUESTO
//				  paquete_mando.payload = pedido_e;
//
//				  sockets_select = sockets_que_espero;
//				  select(descriptor_maximo+1,NULL,&sockets_select,NULL,NULL);
//
//				  if((send(socket_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL)) == -1){
//					  perror("send");
//					  return;
//				  }
//				  //send(socket_ppd,&paquete_mando,sizeof(nipc),0);
//				  if(paquete_mando.payload.direccionSector == 9999) printf("MANDE TODO \n");
///*
//				  if((recv(socket_ppd,&paquete_recibo,sizeof(nipc),0)) == -1){
//					  perror("recv");
//				  }
//*/
//				  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
//				  encontrado_y_removido = suprimir_pedido_especifico_de_cola(&frente_cola_planificador, pedido_e);
//				  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
//				  contador++;
//			  //}else pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
//
//		  }
		  /*for(i=0; i!= cantidadSectores; i++){
			  /*
			  while(flag_escritura == 0){
				  i++;
				  i--;
			  }

			  if((recv(socket_ppd,&paquete_recibo,sizeof(nipc),0)) == -1){
				  perror("recv");
			  }

		  }
*/
		  	// uint32_t entro = 0;
		  pthread_mutex_lock (&(frente_cola_planificador->mutex_en_proceso));
		  if(frente_cola_planificador->pedidos_en_proceso != NULL){
		  	  while(frente_cola_planificador->pedidos_en_proceso != NULL){
				  //pthread_mutex_lock (&(frente_cola_planificador->mutex_en_proceso));
				  pedido_e = frente_cola_planificador->pedidos_en_proceso->pedido;
				  pthread_mutex_unlock (&(frente_cola_planificador->mutex_en_proceso));
				  paquete_mando.type = ESCRITURA;
				  paquete_mando.payloadlength = sizeof(t_pedido);
				  //frente_cola_planificador->siguiente->pedido.lectura_o_escritura = 'E'; YA ESTA PUESTO
				  paquete_mando.payload = pedido_e;
					 //entro = 1;
				  sockets_select = sockets_que_espero;
				  select(descriptor_maximo+1,NULL,&sockets_select,NULL,NULL);
				  send(socket_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);
	/*
				  if((recv(socket_ppd,&paquete_recibo,sizeof(nipc),0)) == -1){
					  perror("recv");
				  }
	*/
				  pthread_mutex_lock (&(frente_cola_planificador->mutex_en_proceso));
						encontrado_y_removido = eliminar_pedido_de_cola_pedidos_en_proceso(&(frente_cola_planificador->pedidos_en_proceso),&(frente_cola_planificador->ultimo_en_proceso),paquete_mando.payload);
						if(frente_cola_planificador->pedidos_en_proceso == NULL) frente_cola_planificador->estado = LISTO;
				  pthread_mutex_unlock (&(frente_cola_planificador->mutex_en_proceso));
			  }
		  }else  pthread_mutex_unlock (&(frente_cola_planificador->mutex_en_proceso));

		  //if(entro) pthread_mutex_unlock (&(frente_cola_planificador->mutex_en_proceso));
		  frente_cola_planificador->estado = LISTO;
		  sincronizacion_en_curso--;
	  }

	  conexion_sincronizacion(estruct_thread.frenteColaGrande,estruct_thread.finColaGrande,paquete_recibo.payload.planificador_id,socket_ppd);

	  if(planificadoresConectados == 1){
		  raid_en_funcionamiento = 1;
	  }

	  flag = 1;
	  //printf("arranco thread %lld \n",puntero1->thread_id);
	  //printf("espero inicio \n");
	  //puts("esta listo un planificador");

	  //printf("arranco thread %lu %s \n",thread_id, estruct_thread.planificador_id);

	  while(1){
		  sem_getvalue(&frente_cola_planificador->semaforo_cola,&valor2);
		  valor = sem_wait(&(frente_cola_planificador->semaforo_cola));
		  //perror("wait");
		  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
		  if(frente_cola_planificador->ppd_muerto == 1){
			  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
			  return;
		  }
		  //if(frente_cola_planificador->siguiente != NULL){
		  pedido_para_trabajar = frente_cola_planificador->siguiente->pedido;
		  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));

			  //printf("hay pedido \n");
			  if(pedido_para_trabajar.lectura_o_escritura == 'E'){

				  flag_escritura = 0;
				  planificador_listo++;

				  if(frente_cola_planificador->ppd_muerto == 1){
					  //pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					  return;
				  }

				  sem_wait(sem_inicio_escritura);

				  if(frente_cola_planificador->ppd_muerto == 1){
					  //pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					  return;
				  }

				  //MANDO PEDIDO A PPD
				  pedido_a_mandar = pedido_para_trabajar;
				  paquete_mando.type = ESCRITURA;
				  paquete_mando.payloadlength = sizeof(t_pedido);
				  paquete_mando.payload = pedido_para_trabajar;
				  //send(socket_ppd,&paquete_mando,sizeof(nipc),0);
				  if((send(socket_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL)) <= 0){
					  perror("send");
					  //return;
				  }

				  if(frente_cola_planificador->ppd_muerto == 1){
					  //pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					  return;
				  }
				  sem_wait(&(frente_cola_planificador->semaforo_escritura));

				  if(frente_cola_planificador->ppd_muerto == 1){
					  //pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					  return;
				  }
				  //printf("escritura ok del sector: %i",paquete_mando.payload.direccionSector);
				  //printf("en el planificador: %s \n",frente_cola_planificador->planificador_id);

				  //printf("proceso escritura en: %s \n",estruct_thread.planificador_id);
				  planificador_termino++;

				  sem_wait(sem_fin_escritura);

				  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
				  if(frente_cola_planificador->ppd_muerto == 1){
					  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					  return;
				  }
				  suprimir_pedido_especifico_de_cola(&frente_cola_planificador, pedido_para_trabajar);
				  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
			  }
			  else {

				  if(pedido_para_trabajar.conexion_pfs_id == -1){
					  //pthread_mutex_unlock (&mutexColaGrande);
					  //ARMO PEDIDO
					  pedido_a_mandar = pedido_para_trabajar;
					  strcpy(ppd_a_sincronizar,pedido_para_trabajar.info);
					  //strcpy(pedido_a_mandar.planificador_id , frente_cola_planificador->planificador_id);
					  paquete_mando.type = LECTURA;
					  paquete_mando.payloadlength = sizeof(t_pedido);
					  paquete_mando.payload = pedido_a_mandar;

					  strcpy(paquete_mando.payload.planificador_id, ppd_a_sincronizar);

					  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
					  pthread_mutex_lock (&(frente_cola_planificador->mutex_en_proceso));
						  if(frente_cola_planificador->ppd_muerto == 1){
							  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
							  pthread_mutex_unlock (&(frente_cola_planificador->mutex_en_proceso));
							  return;
						  }
						  fin_colaPedidosEnProceso = agregar_pedido_a_cola_pedidos_en_proceso(&(frente_cola_planificador->pedidos_en_proceso),&(frente_cola_planificador->ultimo_en_proceso),paquete_mando.payload);
					  pthread_mutex_unlock (&(frente_cola_planificador->mutex_en_proceso));
					  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));

					  //ENVIO PEDIDO
					  //send(socket_ppd,&paquete_mando,sizeof(nipc),0);
					  if((send(socket_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL)) <= 0){
						  perror("send");
						  //return;
					  }

					  //printf("mande el sector %i \n",paquete_mando.payload.direccionSector);
					  //puts("ERRORRRRRRRRRR");

					  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
					  if(frente_cola_planificador->ppd_muerto == 1){
						  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
						  return;
					  }
					  encontrado_y_removido = suprimir_pedido_especifico_de_cola(&frente_cola_planificador, pedido_a_mandar);
					  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));

				  }else{
					  //ARMO PEDIDO

					  pedido_a_mandar = pedido_para_trabajar;
					  paquete_mando.type = LECTURA;
					  paquete_mando.payloadlength = sizeof(t_pedido);
					  paquete_mando.payload = pedido_a_mandar;

					  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
					  pthread_mutex_lock (&(frente_cola_planificador->mutex_en_proceso));
					  if(frente_cola_planificador->ppd_muerto == 1){
						  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
						  pthread_mutex_unlock (&(frente_cola_planificador->mutex_en_proceso));
						  return;
					  }
					  fin_colaPedidosEnProceso = agregar_pedido_a_cola_pedidos_en_proceso(&(frente_cola_planificador->pedidos_en_proceso),&(frente_cola_planificador->ultimo_en_proceso),pedido_a_mandar);
					  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					   pthread_mutex_unlock (&(frente_cola_planificador->mutex_en_proceso));
					  //ENVIO PEDIDO
					  /*if((send(socket_ppd,&paquete_mando,sizeof(nipc),0)) <= 0){
							desconexion_ppd(estruct_thread.frenteColaGrande,estruct_thread.planificador_id);
							pthread_mutex_lock (&(puntero1->mutex_ppd));
							pthread_cancel(thread_recibo_info_id);
							pthread_mutex_unlock (&(puntero1->mutex_ppd));
							pthread_exit();
							//perror(send");
							//exit(1);
					  }
					  */
					  if((send(socket_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL)) <= 0){
						  perror("send");
						  //return;
					  }
					  //puts("mande pedido a ppd sector 555");

					  //printf("mande el sector %i \n",paquete_mando.payload.direccionSector);

					  pthread_mutex_lock (&(frente_cola_planificador->mutex_ppd));
					  if(frente_cola_planificador->ppd_muerto == 1){
						  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
						  return;
					  }
					  encontrado_y_removido = suprimir_pedido_especifico_de_cola(&frente_cola_planificador, pedido_a_mandar);
					  pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
					  /*
						  //RECIBO INFO
						  recv(socket_ppd,&paquete_recibo,sizeof(nipc),0);
						  //DEVUELVO A PFS
						  paquete_mando.payload = paquete_recibo.payload;
						  paquete_mando.type = paquete_recibo.type;
						  send(pedido_a_mandar.conexion_pfs_id,&paquete_mando,sizeof(nipc),0);
					 */
				   }
				  //printf("proceso lectura en: %s \n",estruct_thread.planificador_id);
			  }
		  //}else pthread_mutex_unlock (&(frente_cola_planificador->mutex_ppd));
	  }
}

void conexion_sincronizacion (t_nodoColaGrande **frente_colaGrande, t_nodoColaGrande **fin_colaGrande,char planificador_id[25], int32_t socket_id){

	if(correr_consola == 1){
		pthread_mutex_lock (&mutexInfoConsola);
		paquete_consola->infoConsola->nuevoPlanificador = 1;
		strcpy(paquete_consola->infoConsola->planificadorNuevo_id,planificador_id);
		pthread_kill(paquete_consola->thread_consola_id,SIGUSR1);
		pthread_mutex_unlock (&mutexInfoConsola);
	}

	if (configuracion.logActivado==1)
			log_info(logger, "MAIN", "Se conecto un nuevo PPD, su ID es: %s",planificador_id);

	if(planificadoresConectados == 0) {

		if (configuracion.logActivado==1)
				log_info(logger, "MAIN", "El RAID entró en funcionamiento");

		if(correr_consola == 1){
			pthread_mutex_lock (&mutexInfoConsola);
			paquete_consola->infoConsola->inicioRaid = 1;
			pthread_kill(paquete_consola->thread_consola_id,SIGUSR1);
			pthread_mutex_unlock (&mutexInfoConsola);
		}
	}

	planificadoresConectados++;

	//memset(estruct_thread.planificador_id,0,LONG_PLANIFICADOR_ID);
	//strcpy(estruct_thread.planificador_id,planificador_id);
	//estruct_thread.frenteColaGrande = *frente_colaGrande;

	//aca iba pthread(Create)
	//printf("thread id: %lld \n",(*fin_colaGrande)->thread_id);

}

void distribucion_pedido(t_pedido pedido, t_nodoColaGrande **frente_colaGrande){
	t_nodoCola *fin_cola_planificadorX = NULL;
	char *string_planificador = {'\0'};

	pthread_mutex_lock (&mutexColaGrande);
	string_planificador = algoritmoDistribucion(frente_colaGrande,pedido.direccionSector,planificadoresConectados,cantidadSectores);
	strcpy(pedido.planificador_id,string_planificador);
	//free(string_planificador);
	pthread_mutex_unlock (&mutexColaGrande);

	if (configuracion.logActivado==1)
			log_info(logger, "MAIN", "Llego un pedido de lectura y se procesará en el disco: %s",string_planificador);

	fin_cola_planificadorX = agregar_pedido_a_cola(frente_colaGrande,pedido);

}

void desconexion_ppd(t_nodoColaGrande **frente_colaGrande,t_nodoColaGrande **fin_colaGrande, char planificador_id[25]){
	t_nodoCola *frente_en_proceso, *pedidos;
	t_nodoColaGrande *frente_grande = *frente_colaGrande;
	bool encontrado_y_removido;
	int32_t comparacion_string;
	t_pedido pedido_aux;

	pthread_mutex_lock (&mutexColaGrande);

	comparacion_string = strcmp(frente_grande->planificador_id, planificador_id);
	while(comparacion_string != 0){
		frente_grande = frente_grande->siguienteGrande;
		if(frente_grande != NULL) comparacion_string = strcmp(frente_grande->planificador_id, planificador_id);
	}

	pthread_mutex_lock (&(frente_grande->mutex_ppd));

	if(frente_grande->estado == LISTO){
		planificadoresConectados --;
	}

	if(correr_consola == 1){
		pthread_mutex_lock (&mutexInfoConsola);
		if(frente_grande->estado == LISTO) paquete_consola->infoConsola->desconexion = 1;
		else paquete_consola->infoConsola->desconexion = 2;
		strcpy(paquete_consola->infoConsola->planificadorNuevo_id,planificador_id);
		pthread_kill(paquete_consola->thread_consola_id,SIGUSR1);
		pthread_mutex_unlock (&mutexInfoConsola);
	}

	if (configuracion.logActivado==1)
		log_info(logger, "MAIN", "Se desconecto un PPD, su ID es: %s",planificador_id);

	if(planificadoresConectados == 0){
		if (configuracion.logActivado==1)
						log_info(logger, "MAIN", "El proceso RAID ha terminado por quedarse sin discos .");
		puts("El raid se quedó sin Discos");
		exit(1);
	}

	//pthread_mutex_lock (&mutexColaGrande);
	frente_grande = suprimir_pedido_especifico_de_cola_grande(frente_colaGrande,fin_colaGrande,planificador_id);
	//pthread_mutex_unlock (&mutexColaGrande);
	if(frente_grande == NULL){
		perror("No existe el planificador a eliminar");
	}

	frente_grande->ppd_muerto = 1;
	sem_post(&(frente_grande->semaforo_cola));
	sem_post(&(frente_grande->semaforo_escritura));

	pthread_mutex_unlock (&(frente_grande->mutex_ppd));

	//CIERRO CONEXION PPD
	close(frente_grande->socket_id);

	frente_en_proceso = frente_grande->pedidos_en_proceso;
	pedidos = frente_grande->siguiente;

	pthread_mutex_lock (&(frente_grande->mutex_ppd));
	//MUEVO PEDIDOS A OTROS PPD
	while(frente_grande->pedidos_en_proceso != NULL){
		pedido_aux = frente_grande->pedidos_en_proceso->pedido;

		pthread_mutex_lock (&(frente_grande->mutex_en_proceso));
			encontrado_y_removido = eliminar_pedido_de_cola_pedidos_en_proceso(&(frente_grande->pedidos_en_proceso),&(frente_grande->ultimo_en_proceso),frente_grande->pedidos_en_proceso->pedido);
		pthread_mutex_unlock (&(frente_grande->mutex_en_proceso));

		pthread_mutex_unlock (&mutexColaGrande);
		if(frente_grande->estado == LISTO) distribucion_pedido(pedido_aux,frente_colaGrande);
		pthread_mutex_lock (&mutexColaGrande);
		//frente_en_proceso = frente_en_proceso->siguiente;
	}

	while(frente_grande->siguiente != NULL){
		pedido_aux = frente_grande->siguiente->pedido;

		//pthread_mutex_lock (&(frente_grande->mutex_en_proceso));
			encontrado_y_removido = suprimir_pedido_especifico_de_cola(&frente_grande,frente_grande->siguiente->pedido);
		//pthread_mutex_unlock (&(frente_grande->mutex_en_proceso));

		pthread_mutex_unlock (&mutexColaGrande);
		if(frente_grande->estado == LISTO) distribucion_pedido(pedido_aux,frente_colaGrande);
		pthread_mutex_lock (&mutexColaGrande);
		//frente_en_proceso = frente_en_proceso->siguiente;
	}
	pthread_mutex_unlock (&mutexColaGrande);
	pthread_mutex_unlock (&(frente_grande->mutex_ppd));
	free(frente_grande);
	//pthread_mutex_lock (&(frente_grande->mutex_ppd));
	//pthread_cancel(frente_grande->thread_id);
}

void pedido_escritura(t_pedido pedido, t_nodoColaGrande **frente_colaGrande){
	t_nodoColaGrande *puntero1 = *frente_colaGrande;
	t_nodoCola *fin_cola_planificadorX = NULL;
	int32_t i;
	nipc paquete_mando;

	planificador_listo = 0;
	planificador_termino = 0;
	pthread_mutex_lock (&mutexColaGrande);
	while(puntero1 != NULL){
		//pthread_mutex_lock (&(puntero1->mutex_ppd));
		strcpy(pedido.planificador_id,(*puntero1).planificador_id);
		pthread_mutex_lock (&(puntero1->mutex_en_proceso));
		if(puntero1->estado == LISTO){
			fin_cola_planificadorX = agregar_pedido_a_frente_de_cola(frente_colaGrande,pedido);
			//printf("METI LA PRIMER ESCRITURA \n");
		}
		else{
			eliminar_pedido_de_cola_en_proceso_de_sector_n(&(puntero1->pedidos_en_proceso),&(puntero1->ultimo_en_proceso),pedido.direccionSector);
			agregar_pedido_a_cola_pedidos_en_proceso(&(puntero1->pedidos_en_proceso),&(puntero1->ultimo_en_proceso),pedido);
		}
		pthread_mutex_unlock (&(puntero1->mutex_en_proceso));
		//pthread_mutex_unlock (&(puntero1->mutex_ppd));
		puntero1 = (*puntero1).siguienteGrande;
	}
	//pthread_mutex_unlock (&mutexColaGrande);

	//planificador_listo = 0;

	while(planificador_listo < planificadoresConectados){
	}

	for ( i=0 ; i < planificadoresConectados ; i++ ){
		//printf("libero inicio \n");
		sem_post (sem_inicio_escritura);
	}

	while(planificador_termino < planificadoresConectados){
	}

	for ( i=0 ; i < planificadoresConectados ; i++ ){
		sem_post (sem_fin_escritura);
	}

	pthread_mutex_unlock (&mutexColaGrande);

	//MANDO ESCRITURA OK A PFS
	paquete_mando.type = ESCRITURA_OK;
	paquete_mando.payload = pedido;
	send(pedido.conexion_pfs_id,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);

	if(correr_consola == 1){
		pthread_mutex_lock (&mutexInfoConsola);
		paquete_consola->infoConsola->escritura = 1;
		pthread_kill(paquete_consola->thread_consola_id,SIGUSR1);
		pthread_mutex_unlock (&mutexInfoConsola);
	}

}

void ver_cambios_consola(){
	pthread_mutex_lock (&mutexInfoConsola);
	if(paquete_consola->infoConsola->nuevoPlanificador == 1){
		printf("Se ha conectado el planificador: %s \n",paquete_consola->infoConsola->planificadorNuevo_id);
		paquete_consola->infoConsola->nuevoPlanificador = 0;
	}
	if(paquete_consola->infoConsola->desconexion == 1){
		printf("Se ha desconectado el planificador: %s \n",paquete_consola->infoConsola->planificadorNuevo_id);
		paquete_consola->infoConsola->desconexion = 0;
	}
	if(paquete_consola->infoConsola->desconexion == 2){
		printf("Se ha cancelado la sincronizacion del planificador: %s \n",paquete_consola->infoConsola->planificadorNuevo_id);
		paquete_consola->infoConsola->desconexion = 0;
	}
	if(paquete_consola->infoConsola->inicioRaid == 1){
		puts("El proceso RAID entró en funcionamiento.");
		paquete_consola->infoConsola->inicioRaid = 0;
	}
	if(paquete_consola->infoConsola->iSincronizacion == 1){
		printf("Se ha iniciado la sincronizacion del un disco, su id es: %s\n",paquete_consola->infoConsola->planificadorNuevo_id);
		printf("Tiempo de Inicio: ");
		printf(ctime(&paquete_consola->infoConsola->inicioSincronizacion));
		//printf("Tiempo de Finalizacion: ");
		//printf(ctime(&paquete_consola->infoConsola->finSincronizacion));
		paquete_consola->infoConsola->iSincronizacion = 0;
	}
	if(paquete_consola->infoConsola->fSincronizacion == 1){
		puts("Se ha realizado una sincronizacion de discos: ");
		//printf("Tiempo de Inicio: ");
		//printf(ctime(&paquete_consola->infoConsola->inicioSincronizacion));
		printf("Tiempo de Finalizacion: ");
		printf(ctime(&paquete_consola->infoConsola->finSincronizacion));
		paquete_consola->infoConsola->fSincronizacion = 0;
	}
	if(paquete_consola->infoConsola->escritura == 1){
		printf("Se ha realizado una escritura en todos los discos. \n");
		paquete_consola->infoConsola->escritura = 0;
	}
	if(paquete_consola->infoConsola->lectura == 1){
		printf("Se ha realizado una lectura del sector %i en el planificador: %s \n",paquete_consola->infoConsola->sector,paquete_consola->infoConsola->planificador_id);
		paquete_consola->infoConsola->lectura = 0;
	}
	if(paquete_consola->infoConsola->lectura == 2){
		printf("Se ha realizado una lectura para sincronizacion dede el planificador: %s \n",paquete_consola->infoConsola->planificador_id);
		paquete_consola->infoConsola->lectura = 0;
	}
	pthread_mutex_unlock (&mutexInfoConsola);
	return;
}

void thread_cliente_pfs (void *parametro){
	int32_t par = 0,i = 0, addrlen = sizeof(struct sockaddr_in);
	int32_t socket_cliente = socket(AF_INET,SOCK_STREAM,0);
	char carac;
	nipc paquete_mando,paquete_recibo;
	int32_t hand_ok;

	//Direccion local pfs
	struct sockaddr_in *direccion_local = malloc(addrlen);
	//Direccion remota(a la que me quiero conectar)
	struct sockaddr_in *direccion_remota = malloc(addrlen);

	direccion_local->sin_family = AF_INET;
	direccion_local->sin_addr.s_addr = INADDR_ANY;
	direccion_local->sin_port = htons(5303);
	bind(socket_cliente,(struct sockaddr *)direccion_local, addrlen);

	direccion_remota->sin_family = AF_INET;
	direccion_remota->sin_addr.s_addr = inet_addr("127.0.0.1");
	direccion_remota->sin_port = htons(5301);

	while((carac = getchar()) != 'a'){
	}
	//while(flag == 0){}
	puts("se va a conectar el pfs");

	connect(socket_cliente,(struct sockaddr *)direccion_remota,addrlen);

	paquete_mando.type = 0;
	paquete_mando.payloadlength = 0;
	if((send(socket_cliente,&paquete_mando,sizeof(nipc),0)) <= 0){
		perror("send");
	}

	if((recv(socket_cliente,&paquete_recibo,sizeof(nipc),0)) <= 0) {
		perror("recv");
		exit (1);
	}

    i=800000;
	while(i != 100000){
		//paquete_mando.type = LECTURA;

		if((i % 3) == 0){
			paquete_mando.type = ESCRITURA;
			paquete_mando.payload.lectura_o_escritura = 'E';
		}
		else {

			paquete_mando.type = LECTURA;
			paquete_mando.payload.lectura_o_escritura = 'L';
		}
		paquete_mando.payload.direccionSector = i;
		paquete_mando.payload.conexion_pfs_id = paquete_recibo.payload.conexion_pfs_id;

		//paquete_mando.payload.info="1";
		//usleep(500);

		if((send(socket_cliente,&paquete_mando,sizeof(nipc),0)) <= 0){
			perror("send");
		}
		//printf("%i \n",paquete_mando.type);
		i++;
	}
	puts("termine de mandar");

	//close(socket_cliente);
}

void thread_recibo_info (void *parametro){
	bool encontrado_y_removido;
	estructuraThread estruct_thread = *(estructuraThread *) parametro;
	t_nodoColaGrande *puntero1 = *(estruct_thread.frenteColaGrande);
	int32_t socket_ppd = estruct_thread.socket_id, comparacion_string;
	nipc paquete_recibo, paquete_mando, aux;
	t_pedido pedido_a_mandar;

	pthread_mutex_lock (&mutexColaGrande);
	comparacion_string = strcmp(puntero1->planificador_id, estruct_thread.planificador_id);
	while((puntero1 != NULL) && (comparacion_string != 0)){
		puntero1 = (*puntero1).siguienteGrande;
		if(puntero1 != NULL) comparacion_string = strcmp(puntero1->planificador_id, estruct_thread.planificador_id);
	}
	pthread_mutex_unlock (&mutexColaGrande);

	while(1){
		if((recv(socket_ppd,&paquete_recibo,sizeof(nipc),MSG_WAITALL)) <= 0){
			//pthread_cancel(puntero1->thread_id);
			desconexion_ppd(estruct_thread.frenteColaGrande,estruct_thread.finColaGrande,estruct_thread.planificador_id);
			return;
			//pthread_mutex_lock (&(puntero1->mutex_ppd));
			//pthread_cancel(puntero1->thread_id);
			//pthread_mutex_unlock (&(puntero1->mutex_ppd));
			//pthread_exit(NULL);
			//perror("recv");
			//exit(1);
		}
		//recv(socket_ppd,&paquete_recibo,sizeof(nipc),0);

		aux = paquete_recibo;

		if((paquete_recibo.payload.lectura_o_escritura == 'L') && (paquete_recibo.payload.conexion_pfs_id != -1)){


			//DEVUELVO A PFS
			paquete_mando.payload = paquete_recibo.payload;
			paquete_mando.payloadlength = sizeof(t_pedido);
			paquete_mando.type = paquete_recibo.type;
			send(paquete_recibo.payload.conexion_pfs_id,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);


			//printf("lectura ok del sector: %i \n",paquete_recibo.payload.direccionSector);

			//puts("envie al pfs la respuesta");

			if(correr_consola == 1){
				pthread_mutex_lock (&mutexInfoConsola);
				paquete_consola->infoConsola->lectura = 1;
				strcpy(paquete_consola->infoConsola->planificador_id,paquete_recibo.payload.planificador_id);
				paquete_consola->infoConsola->sector = paquete_recibo.payload.direccionSector;
				pthread_kill(paquete_consola->thread_consola_id,SIGUSR1);
				pthread_mutex_unlock (&mutexInfoConsola);
			}

			pthread_mutex_lock (&(puntero1->mutex_en_proceso));
			encontrado_y_removido = eliminar_pedido_de_cola_pedidos_en_proceso(&(puntero1->pedidos_en_proceso),&(puntero1->ultimo_en_proceso),paquete_recibo.payload);
			pthread_mutex_unlock (&(puntero1->mutex_en_proceso));

		}
		if(paquete_recibo.payload.conexion_pfs_id == -1){
			if(paquete_recibo.payload.lectura_o_escritura == 'L'){

				pthread_mutex_lock (&(puntero1->mutex_en_proceso));
					encontrado_y_removido = eliminar_pedido_de_cola_pedidos_en_proceso(&(puntero1->pedidos_en_proceso),&(puntero1->ultimo_en_proceso),paquete_recibo.payload);
				pthread_mutex_unlock (&(puntero1->mutex_en_proceso));

				paquete_recibo.payload.lectura_o_escritura = 'E';
				//strcpy(paquete_recibo.payload.planificador_id,frente_cola_planificador->siguiente->pedido.info);

				agregar_pedido_a_cola(estruct_thread.frenteColaGrande,paquete_recibo.payload);

				//puts("lei para sincronizacion");
				/*
				if(correr_consola == 1){
					pthread_mutex_lock (&mutexInfoConsola);
					paquete_consola->infoConsola->lectura = 2;
					strcpy(paquete_consola->infoConsola->planificador_id,paquete_recibo.payload.planificador_id);
					pthread_kill(paquete_consola->thread_consola_id,SIGUSR1);
					pthread_mutex_unlock (&mutexInfoConsola);
				}
				*/
			}
			else{
				sem_post(&(puntero1->semaforo_escritura));

				//printf("escritura %i",paquete_recibo.payload.direccionSector);
				if(paquete_recibo.payload.direccionSector == cantidadSectores-1){
					  if(correr_consola == 1){
						  pthread_mutex_lock (&mutexInfoConsola);
						  paquete_consola->infoConsola->fSincronizacion = 1;
						  time(&paquete_consola->infoConsola->finSincronizacion);
						  pthread_kill(paquete_consola->thread_consola_id,SIGUSR1);
						  pthread_mutex_unlock (&mutexInfoConsola);
					  }
				}
			}
		}
		if((paquete_recibo.payload.lectura_o_escritura == 'E') && (paquete_recibo.payload.conexion_pfs_id != -1)){
			paquete_escritura = paquete_recibo;
			sem_post(&(puntero1->semaforo_escritura));

		}
	}
}
